
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'  # or any {'0', '1', '2'}

# Helper libraries
import datetime
import time
from numpy.random import seed
from packaging import version
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import seaborn as sns
from sklearn.metrics import confusion_matrix, accuracy_score, auc, f1_score, precision_score, recall_score
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.manifold import TSNE
from sklearn.ensemble import RandomForestClassifier

from collections import Counter
import numpy as np
import pandas as pd

# TensorFlow and tf.keras
import tensorflow as tf
tf.debugging.set_log_device_placement(False)

from tensorflow.keras.utils import to_categorical
from tensorflow import keras
from tensorflow.keras import preprocessing
from tensorflow.keras import models, layers
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Embedding, SimpleRNN,RNN, LSTM, Bidirectional, GRU
from tensorflow.keras.layers import Dense, Flatten
from tensorflow.keras.layers import MaxPooling1D, MaxPooling2D, BatchNormalization
from tensorflow.keras.layers import Dropout, Flatten, Input, Dense
from tensorflow.keras.datasets import imdb


print("Num GPUs Available: ", len(tf.config.experimental.list_physical_devices('GPU')))

Num GPUs Available:  0


from google.colab import drive
drive.mount('/content/drive')

Mounted at /content/drive


(data, labels), (_, _) = tf.keras.datasets.imdb.load_data(
    path='imdb.npz', num_words=None, skip_top=0, maxlen=None, 
    seed=113, start_char=1, oov_char=2, index_from=3)

C:\Users\brown\anaconda3\envs\tf-gpu\lib\site-packages\tensorflow_core\python\keras\datasets\imdb.py:129: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray
  x_train, y_train = np.array(xs[:idx]), np.array(labels[:idx])
C:\Users\brown\anaconda3\envs\tf-gpu\lib\site-packages\tensorflow_core\python\keras\datasets\imdb.py:130: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray
  x_test, y_test = np.array(xs[idx:]), np.array(labels[idx:])


print(f"There are {len(data)} IMDb Film Reviews with {len(labels)} labels.") 
print(f"There are {len(set(labels))} different label categories.")

There are 25000 IMDb Film Reviews with 25000 labels.
There are 2 different label categories.


classes = {0:'Negative',1:'Positive'}


word_index = tf.keras.datasets.imdb.get_word_index()
reverse_word_index = dict([(value, key) for (key, value) in word_index.items()])


for x in range(3):

    print("Review:"," ".join([reverse_word_index.get(i-3,"#") for i in data[x]]))
    print("Label:",classes[labels[x]])
    print()

Review: # this film was just brilliant casting location scenery story direction everyone's really suited the part they played and you could just imagine being there robert redford's is an amazing actor and now the same being director norman's father came from the same scottish island as myself so i loved the fact there was a real connection with this film the witty remarks throughout the film were great it was just brilliant so much that i bought the film as soon as it was released for retail and would recommend it to everyone to watch and the fly fishing was amazing really cried at the end it was so sad and you know what they say if you cry at a film it must have been good and this definitely was also congratulations to the two little boy's that played the part's of norman and paul they were just brilliant children are often left out of the praising list i think because the stars that play them all grown up are such a big profile for the whole film but these children are amazing and should be praised for what they have done don't you think the whole story was so lovely because it was true and was someone's life after all that was shared with us all
Label: Positive

Review: # big hair big boobs bad music and a giant safety pin these are the words to best describe this terrible movie i love cheesy horror movies and i've seen hundreds but this had got to be on of the worst ever made the plot is paper thin and ridiculous the acting is an abomination the script is completely laughable the best is the end showdown with the cop and how he worked out who the killer is it's just so damn terribly written the clothes are sickening and funny in equal measures the hair is big lots of boobs bounce men wear those cut tee shirts that show off their stomachs sickening that men actually wore them and the music is just synthesiser trash that plays over and over again in almost every scene there is trashy music boobs and paramedics taking away bodies and the gym still doesn't close for bereavement all joking aside this is a truly bad film whose only charm is to look back on the disaster that was the 80's and have a good old laugh at how bad everything was back then
Label: Negative

Review: # this has to be one of the worst films of the 1990s when my friends i were watching this film being the target audience it was aimed at we just sat watched the first half an hour with our jaws touching the floor at how bad it really was the rest of the time everyone else in the theatre just started talking to each other leaving or generally crying into their popcorn that they actually paid money they had earnt working to watch this feeble excuse for a film it must have looked like a great idea on paper but on film it looks like no one in the film has a clue what is going on crap acting crap costumes i can't get across how embarrasing this is to watch save yourself an hour a bit of your life
Label: Negative


indexes = [word for doc in data for word in doc]
print(f"There are {len(indexes)} words in the data corpus")

There are 5967841 words in the data corpus


corpus = [reverse_word_index.get(index,'?') for index in indexes]
corpus_freq = Counter(corpus).most_common()
corpus_freq[:50]

[('of', 336148),
 ('to', 164097),
 ('is', 163040),
 ('br', 145847),
 ('in', 135708),
 ('it', 107313),
 ('i', 101871),
 ('this', 93934),
 ('that', 79058),
 ('was', 77142),
 ('as', 75974),
 ('for', 69787),
 ('with', 48195),
 ('movie', 46927),
 ('but', 44335),
 ('film', 44122),
 ('on', 43564),
 ('not', 42594),
 ('you', 39095),
 ('are', 34188),
 ('his', 30610),
 ('have', 29877),
 ('he', 29425),
 ('be', 29366),
 ('one', 27726),
 ('all', 26952),
 ('at', 26948),
 ('by', 26513),
 ('the', 25000),
 ('an', 23953),
 ('they', 23507),
 ('who', 22539),
 ('so', 21538),
 ('from', 21139),
 ('like', 20599),
 ('her', 20586),
 ('or', 20494),
 ('just', 20272),
 ('about', 18407),
 ("it's", 17994),
 ('out', 17759),
 ('has', 17371),
 ('if', 17153),
 ('some', 17092),
 ('what', 16790),
 ('there', 16790),
 ('good', 15743),
 ('more', 15735),
 ('when', 15349),
 ('very', 15100)]


uniques = [word for word,freq in Counter(corpus).items() if freq == 1]
print(f"There are {len(uniques)} words that occur just once in the data corpus totaling 1638886 words")

There are 36577 words that occur just once in the data corpus totaling 1638886 words


corpus_freq[:-26:-1]

[('johnnys', 1),
 ('geezers', 1),
 ('isolative', 1),
 ('legitimates', 1),
 ('caisse', 1),
 ("'eliminated'", 1),
 ('merritt', 1),
 ("'willy", 1),
 ('proyas', 1),
 ("'giants'", 1),
 ("artimisia's", 1),
 ('worldy', 1),
 ('best\x97but', 1),
 ('protractor', 1),
 ('manner\x85', 1),
 ('amit', 1),
 ("tong's", 1),
 ('1870', 1),
 ('arjuna', 1),
 ('nickson', 1),
 ('examp', 1),
 ("'lauren'", 1),
 ('epic\x85', 1),
 ("sherman's", 1),
 ("bennett'", 1)]


unique_indexes = list(set(indexes))
print(f"There are {len(unique_indexes)} words in the data corpus that represent the vocabulary")

There are 88585 words in the data corpus that represent the vocabulary


uniques[:25]

['gretal',
 'troble',
 'cavil',
 'hiyao',
 'freshened',
 'dedications',
 'mayfair',
 '498',
 'zigfield',
 'wrongdoing',
 "meloni's",
 'bullit',
 'stygian',
 "'menaikkan'",
 'glitched',
 "gods'",
 "'daring'",
 'enrapture',
 "shep'",
 'evolutions',
 'apricorn',
 'zeland',
 'hittite',
 "pair''",
 "'count'"]


doc_sizes = ([len(lst) for lst in data]) # num of words in each document
print(f"Number of words in IMDb Reviews: {min(doc_sizes)} to {max(doc_sizes)}")
print(f"There are a total of {sum(doc_sizes)} words in the data corpus")

Number of words in IMDb Reviews: 11 to 2494
There are a total of 5967841 words in the data corpus


plt.figure(figsize=[12,6])
plt.hist(doc_sizes, bins=20,range = (0,800))
plt.xlabel("Words Per Document")
plt.ylabel("Number of IMDb Reviews")

Text(0, 0.5, 'Number of IMDb Reviews')


#IMDb data has 25,000 already designated for training/testing
#Will join both sets then perform manual 80/20 split
voc_size=10000

(train_data, train_labels),(test_data, test_labels) = tf.keras.datasets.imdb.load_data(
    path='imdb.npz', num_words=voc_size, skip_top=26, maxlen=300,
    seed=113, start_char=1, oov_char=2, index_from=3)

X = np.append(train_data,test_data)
y = np.append(train_labels,test_labels)

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=1)

X_train_seq = preprocessing.sequence.pad_sequences(X_train, maxlen=299)
X_test_seq = preprocessing.sequence.pad_sequences(X_test, maxlen=299)

print(y_train.shape, y_test.shape)
print()
print('Word Sequence:',X_train[0])
print('Label:',y_train[0])
#X_train = tf.keras.preprocessing.sequence.pad_sequences(X_train, padding='post')
#X_test = tf.keras.preprocessing.sequence.pad_sequences(X_test, padding='post')

Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/imdb.npz
17465344/17464789 [==============================] - 0s 0us/step
(30800,) (7701,)

Word Sequence: [2, 2, 114, 2, 2, 2, 2, 2, 2732, 2, 55, 1564, 185, 250, 271, 2, 2383, 2, 1787, 2, 2, 1007, 2, 41, 922, 8827, 1720, 747, 153, 908, 50, 59, 892, 56, 2, 41, 8827, 1138, 1432, 2, 295, 36, 2106, 2, 32, 2, 1370, 41, 799, 435, 2, 3751, 2, 1007, 413, 788, 2, 2, 2, 51, 166, 2, 2, 38, 318, 2, 2, 752, 2, 1763, 114, 26, 2, 307, 5665, 2, 2, 105, 261, 2, 922, 8827, 1432, 2, 2, 2440, 46, 4934, 29, 47, 3143, 7843, 1515, 1553, 2, 1048, 6260, 2, 261, 2, 922, 799, 37, 75, 67, 2, 2183, 5519, 134, 7843, 59, 152, 28, 2, 281, 2, 2, 42, 2972, 2, 89, 76, 2, 99, 76, 2, 261, 2, 1155, 250, 2, 2, 4295, 2, 41, 8827, 1757, 59, 3751, 659, 2, 2124, 2, 393, 2, 192, 2, 41, 799, 2, 64, 2, 1280, 250, 103, 32, 2, 2, 2, 91, 318, 561, 2, 2, 2, 2, 54, 2, 185, 250, 2, 2, 8827, 1432, 417, 570, 997, 68, 3224, 2, 257, 85, 2, 191, 2283, 126, 319, 53, 307, 1301, 731, 2, 2, 2, 2, 2, 2, 2, 2, 2, 32, 134, 771, 2, 2, 2, 371, 307, 2, 2, 2, 2, 30, 2, 2, 2, 30, 110, 174, 2, 174, 790, 46, 2, 158]
Label: 1


model = models.Sequential()

# 299 Time-steps
# 300 Dimension Word Embedding per Time-step
model.add(Embedding(input_dim = voc_size, output_dim = 300, input_length = X_train_seq.shape[1]))

# 32 RNN Units
model.add(SimpleRNN(units=32,activation='tanh',use_bias=True))

# 1 Dense Layer Node
model.add(Dense(1, activation='sigmoid'))

model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['accuracy'])
model.summary()

Model: "sequential"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
embedding (Embedding)        (None, 299, 300)          3000000   
_________________________________________________________________
simple_rnn (SimpleRNN)       (None, 32)                10656     
_________________________________________________________________
dense (Dense)                (None, 1)                 33        
=================================================================
Total params: 3,010,689
Trainable params: 3,010,689
Non-trainable params: 0
_________________________________________________________________


num_units = 32
num_features = 300
recurrent_weights = num_units * num_units
input_weights = num_features * num_units

recurrent_weights + input_weights + num_units

10656


# Run when results have already been partially gathered
rnn_results = pd.read_csv('/content/drive/MyDrive/Research Assignment 4/RNN_Results.csv', header=0, index_col=0)


rnn_results['Model'].count()

94


#rnn_results = pd.DataFrame(columns=['Model','Embed_Dims','RNN Layers','RNN Units','Epochs','Bidirectional','Time','Test Accuracy','Test Precision','Test Recall','Test F1'])

# Run when results have already been partially gathered
rnn_results = pd.read_csv('/content/drive/MyDrive/Research Assignment 4/RNN_Results.csv', header=0, index_col=0)

for RNN_units in [8,16,32,64]:
    
    for RNN_layers in [1,2,3]:

        for bidirectional in [0,1]:
    
            for dims in [100,300,500]:

                num_epochs = 5

                if bidirectional == 1:
                    model_name = 'RNN_{}_Dims_{}_Bidirectional_{}_Units'.format(dims,RNN_layers,RNN_units)

                else:
                    model_name = 'RNN_{}_Dims_{}_Layers_{}_Units'.format(dims,RNN_layers,RNN_units)

                if rnn_results[rnn_results['Model']==model_name]['Model'].count() > 0:

                  print('{} already exists'.format(model_name))
                  continue

                start_time = time.time()

                print('Word Embedding Dims:',dims)
                print('RNN Layers:',RNN_layers)
                print('RNN Units:',RNN_units)
                if bidirectional == 1:
                  print('Bidirectional Layer(s)')
                print('-----------------------')

                seed(5)
                tf.random.set_seed(5)

                model = models.Sequential()
                model.add(Embedding(input_dim = voc_size, output_dim = dims, input_length = X_train_seq.shape[1]))
                
                if RNN_layers > 1:
                    
                    for layers in range(1,RNN_layers):
                        
                        if bidirectional == 1:
                          model.add(Bidirectional(SimpleRNN(units=RNN_units, return_sequences=True)))
                        else:
                          model.add(SimpleRNN(units=RNN_units, return_sequences=True))

                if bidirectional == 1:   
                    model.add(Bidirectional(SimpleRNN(units=RNN_units)))
                else:    
                    model.add(SimpleRNN(units=RNN_units))

                model.add(Dense(1, activation='sigmoid'))

                model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['Precision','Recall','accuracy'])

                history = model.fit(X_train_seq, y_train, batch_size=128, epochs=num_epochs, validation_split=0.2, verbose=False)

                total_time = time.time() - start_time

                loss, precision, recall, accuracy = model.evaluate(X_test_seq, y_test, verbose=0)

                f1_score = (2 * precision * recall) / (precision + recall)

                print('Accuracy:',accuracy)
                print('Precision:',precision)
                print('Recall:',recall)
                print('F1:',f1_score)
                print('Total Time (s):',total_time)
                print()

                acc = history.history['accuracy']
                val_acc = history.history['val_accuracy']
                loss = history.history['loss']
                val_loss = history.history['val_loss']

                print('Model Accuracy Trend')
                print('--------------------')
                plot = plt.plot(range(1, len(acc) + 1), history.history['accuracy'], label = 'Training')
                plot = plt.plot(range(1, len(val_acc) + 1), history.history['val_accuracy'], label = 'Validation')
                plot = plt.title('Training and Validation Accuracy')
                plot = plt.xlabel('Epochs')
                plot = plt.ylabel('Accuracy')
                plot = plt.legend()
                plt.show()
                print()

                print('Confusion Matrix')
                print('----------------')
                pred_test = model.predict_classes(X_test_seq)

                conf_matrix = tf.math.confusion_matrix(y_test, pred_test)

                fig, ax = plt.subplots(figsize=(10,8))
                ax = sns.heatmap(conf_matrix, annot=True, fmt='g')

                ax.set_xlabel("Predicted Classes")
                ax.set_ylabel("Actual Classes")
                ax.set_xticklabels(['Negative','Positive'])
                ax.set_yticklabels(['Negative','Positive'], va='center')
                plt.show()
                print()

                model.save('/content/drive/MyDrive/Research Assignment 4/'+model_name)
                print()

                rnn_results = rnn_results.append(
                    {'Model':model_name,
                    'Embed_Dims':dims,
                    'RNN Layers':RNN_layers,
                    'RNN Units':RNN_units,
                    'Bidirectional':bidirectional,
                    'Epochs':num_epochs,
                    'Time':total_time,
                    'Test Accuracy':accuracy,
                    'Test Precision':precision,
                    'Test Recall':recall,
                    'Test F1':f1_score
                    }, ignore_index=True)
                
                rnn_results.to_csv('/content/drive/MyDrive/Research Assignment 4/'+'RNN_Results.csv')

RNN_100_Dims_1_Layers_8_Units already exists
RNN_300_Dims_1_Layers_8_Units already exists
RNN_500_Dims_1_Layers_8_Units already exists
RNN_100_Dims_1_Bidirectional_8_Units already exists
RNN_300_Dims_1_Bidirectional_8_Units already exists
RNN_500_Dims_1_Bidirectional_8_Units already exists
RNN_100_Dims_2_Layers_8_Units already exists
RNN_300_Dims_2_Layers_8_Units already exists
RNN_500_Dims_2_Layers_8_Units already exists
RNN_100_Dims_2_Bidirectional_8_Units already exists
RNN_300_Dims_2_Bidirectional_8_Units already exists
RNN_500_Dims_2_Bidirectional_8_Units already exists
RNN_100_Dims_3_Layers_8_Units already exists
RNN_300_Dims_3_Layers_8_Units already exists
RNN_500_Dims_3_Layers_8_Units already exists
RNN_100_Dims_3_Bidirectional_8_Units already exists
RNN_300_Dims_3_Bidirectional_8_Units already exists
RNN_500_Dims_3_Bidirectional_8_Units already exists
RNN_100_Dims_1_Layers_16_Units already exists
RNN_300_Dims_1_Layers_16_Units already exists
RNN_500_Dims_1_Layers_16_Units already exists
RNN_100_Dims_1_Bidirectional_16_Units already exists
RNN_300_Dims_1_Bidirectional_16_Units already exists
RNN_500_Dims_1_Bidirectional_16_Units already exists
RNN_100_Dims_2_Layers_16_Units already exists
RNN_300_Dims_2_Layers_16_Units already exists
RNN_500_Dims_2_Layers_16_Units already exists
RNN_100_Dims_2_Bidirectional_16_Units already exists
RNN_300_Dims_2_Bidirectional_16_Units already exists
RNN_500_Dims_2_Bidirectional_16_Units already exists
RNN_100_Dims_3_Layers_16_Units already exists
RNN_300_Dims_3_Layers_16_Units already exists
RNN_500_Dims_3_Layers_16_Units already exists
RNN_100_Dims_3_Bidirectional_16_Units already exists
RNN_300_Dims_3_Bidirectional_16_Units already exists
RNN_500_Dims_3_Bidirectional_16_Units already exists
RNN_100_Dims_1_Layers_32_Units already exists
RNN_300_Dims_1_Layers_32_Units already exists
RNN_500_Dims_1_Layers_32_Units already exists
RNN_100_Dims_1_Bidirectional_32_Units already exists
RNN_300_Dims_1_Bidirectional_32_Units already exists
RNN_500_Dims_1_Bidirectional_32_Units already exists
RNN_100_Dims_2_Layers_32_Units already exists
RNN_300_Dims_2_Layers_32_Units already exists
RNN_500_Dims_2_Layers_32_Units already exists
RNN_100_Dims_2_Bidirectional_32_Units already exists
RNN_300_Dims_2_Bidirectional_32_Units already exists
RNN_500_Dims_2_Bidirectional_32_Units already exists
RNN_100_Dims_3_Layers_32_Units already exists
RNN_300_Dims_3_Layers_32_Units already exists
RNN_500_Dims_3_Layers_32_Units already exists
RNN_100_Dims_3_Bidirectional_32_Units already exists
RNN_300_Dims_3_Bidirectional_32_Units already exists
RNN_500_Dims_3_Bidirectional_32_Units already exists
RNN_100_Dims_1_Layers_64_Units already exists
RNN_300_Dims_1_Layers_64_Units already exists
RNN_500_Dims_1_Layers_64_Units already exists
RNN_100_Dims_1_Bidirectional_64_Units already exists
RNN_300_Dims_1_Bidirectional_64_Units already exists
RNN_500_Dims_1_Bidirectional_64_Units already exists
RNN_100_Dims_2_Layers_64_Units already exists
RNN_300_Dims_2_Layers_64_Units already exists
RNN_500_Dims_2_Layers_64_Units already exists
RNN_100_Dims_2_Bidirectional_64_Units already exists
RNN_300_Dims_2_Bidirectional_64_Units already exists
Word Embedding Dims: 500
RNN Layers: 2
RNN Units: 64
Bidirectional Layer(s)
-----------------------
Accuracy: 0.7904168367385864
Precision: 0.811975359916687
Recall: 0.754942774772644
F1: 0.782421133167952
Total Time (s): 770.132120847702

Model Accuracy Trend
--------------------

Confusion Matrix
----------------
WARNING:tensorflow:From <ipython-input-7-3222db7d8c0b>:93: Sequential.predict_classes (from tensorflow.python.keras.engine.sequential) is deprecated and will be removed after 2021-01-01.
Instructions for updating:
Please use instead:* `np.argmax(model.predict(x), axis=-1)`,   if your model does multi-class classification   (e.g. if it uses a `softmax` last-layer activation).* `(model.predict(x) > 0.5).astype("int32")`,   if your model does binary classification   (e.g. if it uses a `sigmoid` last-layer activation).

WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/tensorflow/python/training/tracking/tracking.py:111: Model.state_updates (from tensorflow.python.keras.engine.training) is deprecated and will be removed in a future version.
Instructions for updating:
This property should not be used in TensorFlow 2.0, as updates are applied automatically.
WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/tensorflow/python/training/tracking/tracking.py:111: Layer.updates (from tensorflow.python.keras.engine.base_layer) is deprecated and will be removed in a future version.
Instructions for updating:
This property should not be used in TensorFlow 2.0, as updates are applied automatically.
INFO:tensorflow:Assets written to: /content/drive/MyDrive/Research Assignment 4/RNN_500_Dims_2_Bidirectional_64_Units/assets

Word Embedding Dims: 100
RNN Layers: 3
RNN Units: 64
-----------------------
Accuracy: 0.8378132581710815
Precision: 0.8723099231719971
Recall: 0.7908428907394409
F1: 0.8295811370930062
Total Time (s): 572.9876418113708

Model Accuracy Trend
--------------------

Confusion Matrix
----------------

INFO:tensorflow:Assets written to: /content/drive/MyDrive/Research Assignment 4/RNN_100_Dims_3_Layers_64_Units/assets

Word Embedding Dims: 300
RNN Layers: 3
RNN Units: 64
-----------------------
Accuracy: 0.8023633360862732
Precision: 0.8235785961151123
Recall: 0.7687304615974426
F1: 0.7952098887923724
Total Time (s): 596.5280871391296

Model Accuracy Trend
--------------------

Confusion Matrix
----------------

INFO:tensorflow:Assets written to: /content/drive/MyDrive/Research Assignment 4/RNN_300_Dims_3_Layers_64_Units/assets

Word Embedding Dims: 500
RNN Layers: 3
RNN Units: 64
-----------------------
Accuracy: 0.6718608140945435
Precision: 0.6697602272033691
Recall: 0.6758584976196289
F1: 0.6727955438976125
Total Time (s): 623.8895761966705

Model Accuracy Trend
--------------------

Confusion Matrix
----------------

INFO:tensorflow:Assets written to: /content/drive/MyDrive/Research Assignment 4/RNN_500_Dims_3_Layers_64_Units/assets

Word Embedding Dims: 100
RNN Layers: 3
RNN Units: 64
Bidirectional Layer(s)
-----------------------
Accuracy: 0.7741851806640625
Precision: 0.7645136713981628
Recall: 0.7913631796836853
F1: 0.7777067567894181
Total Time (s): 1040.8302595615387

Model Accuracy Trend
--------------------

Confusion Matrix
----------------


#rnn_results = pd.read_csv('/content/drive/MyDrive/Research Assignment 4/RNN_Results.csv', header=0, index_col=0)
rnn_results.sort_values(by='Test F1',ascending=False).head()


top_rnn = rnn_results.sort_values(by='Test F1',ascending=False).head().reset_index(drop=True).iloc[0]


model = keras.models.load_model('/content/drive/MyDrive/Research Assignment 4/{}'.format(top_rnn['Model']))

print('Model Summary')
print('-------------')
model.summary()

print('Confusion Matrix')
print('----------------')
pred_test = model.predict_classes(X_test_seq)

conf_matrix = tf.math.confusion_matrix(y_test, pred_test)

fig, ax = plt.subplots(figsize=(10,8))
ax = sns.heatmap(conf_matrix, annot=True, fmt='g')

ax.set_xlabel("Predicted Classes")
ax.set_ylabel("Actual Classes")
ax.set_xticklabels(['Negative','Positive'])
ax.set_yticklabels(['Negative','Positive'], va='center')
plt.show()
print()


for RNN_units in range(1,top_rnn['RNN Units']):

  dims = top_rnn['Embed_Dims']
  RNN_layers = top_rnn['RNN Layers']
  bidirectional = top_rnn['Bidirectional']
  num_epochs = 5

  start_time = time.time()

  print('Word Embedding Dims:',dims)
  print('RNN Layers:',RNN_layers)
  print('RNN Units:',RNN_units)
  print('-----------------------')

  seed(5)
  tf.random.set_seed(5)

  model = models.Sequential()
  model.add(Embedding(input_dim = voc_size, output_dim = dims, input_length = X_train_seq.shape[1]))

  if RNN_layers > 1:
                    
    for layers in range(1,RNN_layers):
      
      if bidirectional == 1:
        model.add(Bidirectional(SimpleRNN(units=RNN_units, return_sequences=True)))
      else:
        model.add(SimpleRNN(units=RNN_units, return_sequences=True))

  if bidirectional == 1:   
      model.add(Bidirectional(SimpleRNN(units=RNN_units)))
  else:    
      model.add(SimpleRNN(units=RNN_units))

  model.add(Dense(1, activation='sigmoid'))

  model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['Precision','Recall','accuracy'])

  history = model.fit(X_train_seq, y_train, batch_size=128, epochs=num_epochs, validation_split=0.2, verbose=False)

  total_time = time.time() - start_time

  loss, precision, recall, accuracy = model.evaluate(X_test_seq, y_test, verbose=0)

  f1_score = (2 * precision * recall) / (precision + recall)

  print('Accuracy:',accuracy)
  print('Precision:',precision)
  print('Recall:',recall)
  print('F1:',f1_score)
  print('Total Time (s):',total_time)
  print()

  acc = history.history['accuracy']
  val_acc = history.history['val_accuracy']
  loss = history.history['loss']
  val_loss = history.history['val_loss']

  print('Model Accuracy Trend')
  print('--------------------')
  plot = plt.plot(range(1, len(acc) + 1), history.history['accuracy'], label = 'Training')
  plot = plt.plot(range(1, len(val_acc) + 1), history.history['val_accuracy'], label = 'Validation')
  plot = plt.title('Training and Validation Accuracy')
  plot = plt.xlabel('Epochs')
  plot = plt.ylabel('Accuracy')
  plot = plt.legend()
  plt.show()
  print()

  print('Confusion Matrix')
  print('----------------')
  pred_test = model.predict_classes(X_test_seq)

  conf_matrix = tf.math.confusion_matrix(y_test, pred_test)

  fig, ax = plt.subplots(figsize=(10,8))
  ax = sns.heatmap(conf_matrix, annot=True, fmt='g')

  ax.set_xlabel("Predicted Classes")
  ax.set_ylabel("Actual Classes")
  ax.set_xticklabels(['Negative','Positive'])
  ax.set_yticklabels(['Negative','Positive'], va='center')
  plt.show()
  print()

  if bidirectional == 1:   
      model_name = 'RNN_{}_Dims_{}_Bidirectional_{}_Units'.format(dims,RNN_layers,RNN_units)
  else:    
      model_name = 'RNN_{}_Dims_{}_Layers_{}_Units'.format(dims,RNN_layers,RNN_units)

  model.save('/content/drive/MyDrive/Research Assignment 4/'+model_name)
  print()

  rnn_results = rnn_results.append(
      {'Model':model_name,
        'Embed_Dims':dims,
        'RNN Layers':RNN_layers,
        'RNN Units':RNN_units,
        'Bidirectional':bidirectional,
        'Epochs':num_epochs,
        'Time':total_time,
        'Test Accuracy':accuracy,
        'Test Precision':precision,
        'Test Recall':recall,
        'Test F1':f1_score
      }, ignore_index=True)
  
  rnn_results.to_csv('/content/drive/MyDrive/Research Assignment 4/'+'RNN_Results.csv')

Word Embedding Dims: 300
RNN Layers: 1
RNN Units: 1
-----------------------
Accuracy: 0.7902869582176208
Precision: 0.832190752029419
Recall: 0.7263267636299133
F1: 0.7756632948569226
Total Time (s): 232.33088493347168

Model Accuracy Trend
--------------------

Confusion Matrix
----------------

INFO:tensorflow:Assets written to: /content/drive/MyDrive/Research Assignment 4/RNN_300_Dims_1_Layers_1_Units/assets

Word Embedding Dims: 300
RNN Layers: 1
RNN Units: 2
-----------------------
Accuracy: 0.7884690165519714
Precision: 0.7570201754570007
Recall: 0.8485952019691467
F1: 0.8001962334422158
Total Time (s): 241.49433016777039

Model Accuracy Trend
--------------------

Confusion Matrix
----------------

INFO:tensorflow:Assets written to: /content/drive/MyDrive/Research Assignment 4/RNN_300_Dims_1_Layers_2_Units/assets

Word Embedding Dims: 300
RNN Layers: 1
RNN Units: 3
-----------------------
Accuracy: 0.8171666264533997
Precision: 0.838521420955658
Recall: 0.7848595380783081
F1: 0.8108035658021469
Total Time (s): 241.63473677635193

Model Accuracy Trend
--------------------

Confusion Matrix
----------------

INFO:tensorflow:Assets written to: /content/drive/MyDrive/Research Assignment 4/RNN_300_Dims_1_Layers_3_Units/assets

Word Embedding Dims: 300
RNN Layers: 1
RNN Units: 4
-----------------------
Accuracy: 0.8219711780548096
Precision: 0.8791781663894653
Recall: 0.7458376884460449
F1: 0.8070373090833944
Total Time (s): 240.14118194580078

Model Accuracy Trend
--------------------

Confusion Matrix
----------------

INFO:tensorflow:Assets written to: /content/drive/MyDrive/Research Assignment 4/RNN_300_Dims_1_Layers_4_Units/assets

Word Embedding Dims: 300
RNN Layers: 1
RNN Units: 5
-----------------------
Accuracy: 0.8006752133369446
Precision: 0.9012860655784607
Recall: 0.6745577454566956
F1: 0.7716113642109909
Total Time (s): 242.0968930721283

Model Accuracy Trend
--------------------

Confusion Matrix
----------------


for dims in [1,2,4,8,16,32,64]:

  RNN_units = top_rnn['RNN Units']
  RNN_layers = top_rnn['RNN Layers']
  bidirectional = top_rnn['Bidirectional']
  num_epochs = 5

  start_time = time.time()

  print('Word Embedding Dims:',dims)
  print('RNN Layers:',RNN_layers)
  print('RNN Units:',RNN_units)
  print('-----------------------')

  seed(5)
  tf.random.set_seed(5)

  model = models.Sequential()
  model.add(Embedding(input_dim = voc_size, output_dim = dims, input_length = X_train_seq.shape[1]))

  if RNN_layers > 1:
                    
    for layers in range(1,RNN_layers):
      
      if bidirectional == 1:
        model.add(Bidirectional(SimpleRNN(units=RNN_units, return_sequences=True)))
      else:
        model.add(SimpleRNN(units=RNN_units, return_sequences=True))

  if bidirectional == 1:   
      model.add(Bidirectional(SimpleRNN(units=RNN_units)))
  else:    
      model.add(SimpleRNN(units=RNN_units))

  model.add(Dense(1, activation='sigmoid'))

  model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['Precision','Recall','accuracy'])

  history = model.fit(X_train_seq, y_train, batch_size=128, epochs=num_epochs, validation_split=0.2, verbose=False)

  total_time = time.time() - start_time

  loss, precision, recall, accuracy = model.evaluate(X_test_seq, y_test, verbose=0)

  f1_score = (2 * precision * recall) / (precision + recall)

  print('Accuracy:',accuracy)
  print('Precision:',precision)
  print('Recall:',recall)
  print('F1:',f1_score)
  print('Total Time (s):',total_time)
  print()

  acc = history.history['accuracy']
  val_acc = history.history['val_accuracy']
  loss = history.history['loss']
  val_loss = history.history['val_loss']

  print('Model Accuracy Trend')
  print('--------------------')
  plot = plt.plot(range(1, len(acc) + 1), history.history['accuracy'], label = 'Training')
  plot = plt.plot(range(1, len(val_acc) + 1), history.history['val_accuracy'], label = 'Validation')
  plot = plt.title('Training and Validation Accuracy')
  plot = plt.xlabel('Epochs')
  plot = plt.ylabel('Accuracy')
  plot = plt.legend()
  plt.show()
  print()

  print('Confusion Matrix')
  print('----------------')
  pred_test = model.predict_classes(X_test_seq)

  conf_matrix = tf.math.confusion_matrix(y_test, pred_test)

  fig, ax = plt.subplots(figsize=(10,8))
  ax = sns.heatmap(conf_matrix, annot=True, fmt='g')

  ax.set_xlabel("Predicted Classes")
  ax.set_ylabel("Actual Classes")
  ax.set_xticklabels(['Negative','Positive'])
  ax.set_yticklabels(['Negative','Positive'], va='center')
  plt.show()
  print()

  if bidirectional == 1:   
      model_name = 'RNN_{}_Dims_{}_Bidirectional_{}_Units'.format(dims,RNN_layers,RNN_units)
  else:    
      model_name = 'RNN_{}_Dims_{}_Layers_{}_Units'.format(dims,RNN_layers,RNN_units)

  model.save('/content/drive/MyDrive/Research Assignment 4/'+model_name)
  print()

  rnn_results = rnn_results.append(
      {'Model':model_name,
        'Embed_Dims':dims,
        'RNN Layers':RNN_layers,
        'RNN Units':RNN_units,
        'Bidirectional':bidirectional,
        'Epochs':num_epochs,
        'Time':total_time,
        'Test Accuracy':accuracy,
        'Test Precision':precision,
        'Test Recall':recall,
        'Test F1':f1_score
      }, ignore_index=True)
  
  rnn_results.to_csv('/content/drive/MyDrive/Research Assignment 4/'+'RNN_Results.csv')

Word Embedding Dims: 1
RNN Layers: 1
RNN Units: 16
-----------------------
Accuracy: 0.8515776991844177
Precision: 0.8884095549583435
Recall: 0.8035899996757507
F1: 0.8438737847484815
Total Time (s): 192.87189722061157

Model Accuracy Trend
--------------------

Confusion Matrix
----------------

INFO:tensorflow:Assets written to: /content/drive/MyDrive/Research Assignment 4/RNN_1_Dims_1_Layers_16_Units/assets

Word Embedding Dims: 2
RNN Layers: 1
RNN Units: 16
-----------------------
Accuracy: 0.8213219046592712
Precision: 0.9284722208976746
Recall: 0.6956295371055603
F1: 0.7953598942377778
Total Time (s): 194.5131118297577

Model Accuracy Trend
--------------------

Confusion Matrix
----------------

INFO:tensorflow:Assets written to: /content/drive/MyDrive/Research Assignment 4/RNN_2_Dims_1_Layers_16_Units/assets

Word Embedding Dims: 4
RNN Layers: 1
RNN Units: 16
-----------------------
Accuracy: 0.8556031584739685
Precision: 0.8863122463226318
Recall: 0.8152965903282166
F1: 0.8493225197575244
Total Time (s): 195.57575750350952

Model Accuracy Trend
--------------------

Confusion Matrix
----------------

INFO:tensorflow:Assets written to: /content/drive/MyDrive/Research Assignment 4/RNN_4_Dims_1_Layers_16_Units/assets

Word Embedding Dims: 8
RNN Layers: 1
RNN Units: 16
-----------------------
Accuracy: 0.7678223848342896
Precision: 0.9469565153121948
Recall: 0.5665972828865051
F1: 0.7089843641185527
Total Time (s): 193.8862292766571

Model Accuracy Trend
--------------------

Confusion Matrix
----------------

INFO:tensorflow:Assets written to: /content/drive/MyDrive/Research Assignment 4/RNN_8_Dims_1_Layers_16_Units/assets

Word Embedding Dims: 16
RNN Layers: 1
RNN Units: 16
-----------------------
Accuracy: 0.8291131258010864
Precision: 0.9247311949729919
Recall: 0.7159209251403809
F1: 0.8070381337946112
Total Time (s): 195.1992106437683

Model Accuracy Trend
--------------------

Confusion Matrix
----------------


# OLD VERSION
for dims in [1,2,4,8,16,32,64]:

  #dims = 300
  RNN_units = 8
  RNN_layers = 1
  num_epochs = 5

  start_time = time.time()

  print('Word Embedding Dims:',dims)
  print('RNN Layers:',RNN_layers)
  print('RNN Units:',RNN_units)
  print('-----------------------')

  seed(5)
  tf.random.set_seed(5)

  model = models.Sequential()
  model.add(Embedding(input_dim = voc_size, output_dim = dims, input_length = X_train_seq.shape[1]))          
  model.add(SimpleRNN(units=RNN_units))
  model.add(Dense(1, activation='sigmoid'))

  model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['Precision','Recall','accuracy'])

  history = model.fit(X_train_seq, y_train, batch_size=128, epochs=num_epochs, validation_split=0.2, verbose=False)

  total_time = time.time() - start_time

  loss, precision, recall, accuracy = model.evaluate(X_test_seq, y_test, verbose=0)

  f1_score = (2 * precision * recall) / (precision + recall)

  print('Accuracy:',accuracy)
  print('Precision:',precision)
  print('Recall:',recall)
  print('F1:',f1_score)
  print('Total Time (s):',total_time)
  print()

  acc = history.history['accuracy']
  val_acc = history.history['val_accuracy']
  loss = history.history['loss']
  val_loss = history.history['val_loss']

  print('Model Accuracy Trend')
  print('--------------------')
  plot = plt.plot(range(1, len(acc) + 1), history.history['accuracy'], label = 'Training')
  plot = plt.plot(range(1, len(val_acc) + 1), history.history['val_accuracy'], label = 'Validation')
  plot = plt.title('Training and Validation Accuracy')
  plot = plt.xlabel('Epochs')
  plot = plt.ylabel('Accuracy')
  plot = plt.legend()
  plt.show()
  print()

  print('Confusion Matrix')
  print('----------------')
  pred_test = model.predict_classes(X_test_seq)

  conf_matrix = tf.math.confusion_matrix(y_test, pred_test)

  fig, ax = plt.subplots(figsize=(10,8))
  ax = sns.heatmap(conf_matrix, annot=True, fmt='g')

  ax.set_xlabel("Predicted Classes")
  ax.set_ylabel("Actual Classes")
  ax.set_xticklabels(['Negative','Positive'])
  ax.set_yticklabels(['Negative','Positive'], va='center')
  plt.show()
  print()

  model_name = 'RNN_{}_Dims_{}_Layers_{}_Units'.format(dims,RNN_layers,RNN_units)

  model.save('/content/drive/MyDrive/Research Assignment 4/'+model_name)
  print()

  rnn_results = rnn_results.append(
      {'Model':model_name,
        'Embed_Dims':dims,
        'RNN Layers':RNN_layers,
        'RNN Units':RNN_units,
        'Epochs':num_epochs,
        'Time':total_time,
        'Test Accuracy':accuracy,
        'Test Precision':precision,
        'Test Recall':recall,
        'Test F1':f1_score
      }, ignore_index=True)
  
  rnn_results.to_csv('/content/drive/MyDrive/Research Assignment 4/'+'RNN_Results.csv')

Word Embedding Dims: 1
RNN Layers: 1
RNN Units: 8
-----------------------
Accuracy: 0.8504090309143066
Precision: 0.8834757804870605
Recall: 0.806711733341217
F1: 0.8433505423636827
Total Time (s): 198.19484329223633

Model Accuracy Trend
--------------------

Confusion Matrix
----------------

INFO:tensorflow:Assets written to: /content/drive/MyDrive/Research Assignment 4/RNN_1_Dims_1_Layers_8_Units/assets

Word Embedding Dims: 2
RNN Layers: 1
RNN Units: 8
-----------------------
Accuracy: 0.8022334575653076
Precision: 0.9427699446678162
Recall: 0.6428200006484985
F1: 0.764423838878281
Total Time (s): 197.7818739414215

Model Accuracy Trend
--------------------

Confusion Matrix
----------------

INFO:tensorflow:Assets written to: /content/drive/MyDrive/Research Assignment 4/RNN_2_Dims_1_Layers_8_Units/assets

Word Embedding Dims: 4
RNN Layers: 1
RNN Units: 8
-----------------------
Accuracy: 0.8453447818756104
Precision: 0.8698076605796814
Recall: 0.8116545081138611
F1: 0.8397254747039624
Total Time (s): 201.54888463020325

Model Accuracy Trend
--------------------

Confusion Matrix
----------------

INFO:tensorflow:Assets written to: /content/drive/MyDrive/Research Assignment 4/RNN_4_Dims_1_Layers_8_Units/assets

Word Embedding Dims: 8
RNN Layers: 1
RNN Units: 8
-----------------------
Accuracy: 0.8671600818634033
Precision: 0.8691442012786865
Recall: 0.8639438152313232
F1: 0.8665362059925739
Total Time (s): 197.23077774047852

Model Accuracy Trend
--------------------

Confusion Matrix
----------------

INFO:tensorflow:Assets written to: /content/drive/MyDrive/Research Assignment 4/RNN_8_Dims_1_Layers_8_Units/assets

Word Embedding Dims: 16
RNN Layers: 1
RNN Units: 8
-----------------------
Accuracy: 0.8563823103904724
Precision: 0.815292477607727
Recall: 0.9209157228469849
F1: 0.864891274158469
Total Time (s): 197.65892910957336

Model Accuracy Trend
--------------------

Confusion Matrix
----------------


rnn_results = pd.read_csv('/content/drive/MyDrive/Research Assignment 4/RNN_Results.csv', header=0, index_col=0)
rnn_results.sort_values(by='Test F1',ascending=False).head()


plot_df = rnn_results[['Embed_Dims','RNN Layers','RNN Units','Bidirectional','Test F1']]

fig, ax = plt.subplots(3,1,figsize=(12,12))

sns.lineplot(x='Embed_Dims',y='Test F1',data=plot_df,hue='Bidirectional',ax=ax[0])
sns.lineplot(x='RNN Layers',y='Test F1',data=plot_df,hue='Bidirectional',ax=ax[1])
sns.lineplot(x='RNN Units',y='Test F1',data=plot_df,hue='Bidirectional',ax=ax[2])

<matplotlib.axes._subplots.AxesSubplot at 0x7f5df06204e0>


lstm_results = pd.DataFrame(columns=['Model','Embed_Dims','LSTM Layers','LSTM Units','Bidirectional','Epochs','Time','Test Accuracy','Test Precision','Test Recall','Test F1'])

for LSTM_units in [8,16,32,64]:
    
    for LSTM_layers in [1,2,3]:

        for bidirectional in [0,1]:
    
            for embed_dims in [100,300,500]:

                dims = embed_dims

                num_epochs = 5

                start_time = time.time()

                print('Word Embedding Dims:',dims)
                print('LSTM Layers:',LSTM_layers)
                print('LSTM Units:',LSTM_units)
                if bidirectional == 1:
                  print('Bidirectional Layer(s)')
                print('-----------------------')

                seed(5)
                tf.random.set_seed(5)

                model = models.Sequential()
                model.add(Embedding(input_dim = voc_size, output_dim = dims, input_length = X_train_seq.shape[1]))
                
                if LSTM_layers > 1:
                    
                    for layers in range(1,LSTM_layers):
                        
                        if bidirectional == 1:
                          model.add(Bidirectional(LSTM(units=LSTM_units, return_sequences=True)))
                        else:
                          model.add(LSTM(units=LSTM_units, return_sequences=True))

                if bidirectional == 1:   
                    model.add(Bidirectional(LSTM(units=LSTM_units)))
                else:    
                    model.add(LSTM(units=LSTM_units))

                model.add(Dense(1, activation='sigmoid'))

                model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['Precision','Recall','accuracy'])

                history = model.fit(X_train_seq, y_train, batch_size=128, epochs=num_epochs, validation_split=0.2, verbose=False)

                total_time = time.time() - start_time

                loss, precision, recall, accuracy = model.evaluate(X_test_seq, y_test, verbose=0)

                f1_score = (2 * precision * recall) / (precision + recall)

                print('Accuracy:',accuracy)
                print('Precision:',precision)
                print('Recall:',recall)
                print('F1:',f1_score)
                print('Total Time (s):',total_time)
                print()

                acc = history.history['accuracy']
                val_acc = history.history['val_accuracy']
                loss = history.history['loss']
                val_loss = history.history['val_loss']

                print('Model Accuracy Trend')
                print('--------------------')
                plot = plt.plot(range(1, len(acc) + 1), history.history['accuracy'], label = 'Training')
                plot = plt.plot(range(1, len(val_acc) + 1), history.history['val_accuracy'], label = 'Validation')
                plot = plt.title('Training and Validation Accuracy')
                plot = plt.xlabel('Epochs')
                plot = plt.ylabel('Accuracy')
                plot = plt.legend()
                plt.show()
                print()

                print('Confusion Matrix')
                print('----------------')
                pred_test = model.predict_classes(X_test_seq)

                conf_matrix = tf.math.confusion_matrix(y_test, pred_test)

                fig, ax = plt.subplots(figsize=(10,8))
                ax = sns.heatmap(conf_matrix, annot=True, fmt='g')

                ax.set_xlabel("Predicted Classes")
                ax.set_ylabel("Actual Classes")
                ax.set_xticklabels(['Negative','Positive'])
                ax.set_yticklabels(['Negative','Positive'], va='center')
                plt.show()
                print()

                if bidirectional == 1:
                    model_name = 'LSTM_{}_Dims_{}_Bidirectional_{}_Units'.format(embed_dims,LSTM_layers,LSTM_units)

                else:
                    model_name = 'LSTM_{}_Dims_{}_Layers_{}_Units'.format(embed_dims,LSTM_layers,LSTM_units)

                model.save('/content/drive/MyDrive/Research Assignment 4/'+model_name)
                print()

                lstm_results = lstm_results.append(
                    {'Model':model_name,
                    'Embed_Dims':dims,
                    'LSTM Layers':LSTM_layers,
                    'LSTM Units':LSTM_units,
                    'Bidirectional':bidirectional,
                    'Epochs':num_epochs,
                    'Time':total_time,
                    'Test Accuracy':accuracy,
                    'Test Precision':precision,
                    'Test Recall':recall,
                    'Test F1':f1_score
                    }, ignore_index=True)
                
                lstm_results.to_csv('/content/drive/MyDrive/Research Assignment 4/'+'LSTM_Results.csv')

Word Embedding Dims: 100
LSTM Layers: 1
LSTM Units: 8
-----------------------
Accuracy: 0.8770289421081543
Precision: 0.9069963693618774
Recall: 0.8397502899169922
F1: 0.8720789131948158
Total Time (s): 39.18390989303589

Model Accuracy Trend
--------------------

Confusion Matrix
----------------
WARNING:tensorflow:From <ipython-input-16-06706ce2034d>:81: Sequential.predict_classes (from tensorflow.python.keras.engine.sequential) is deprecated and will be removed after 2021-01-01.
Instructions for updating:
Please use instead:* `np.argmax(model.predict(x), axis=-1)`,   if your model does multi-class classification   (e.g. if it uses a `softmax` last-layer activation).* `(model.predict(x) > 0.5).astype("int32")`,   if your model does binary classification   (e.g. if it uses a `sigmoid` last-layer activation).

WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/tensorflow/python/training/tracking/tracking.py:111: Model.state_updates (from tensorflow.python.keras.engine.training) is deprecated and will be removed in a future version.
Instructions for updating:
This property should not be used in TensorFlow 2.0, as updates are applied automatically.
WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/tensorflow/python/training/tracking/tracking.py:111: Layer.updates (from tensorflow.python.keras.engine.base_layer) is deprecated and will be removed in a future version.
Instructions for updating:
This property should not be used in TensorFlow 2.0, as updates are applied automatically.
INFO:tensorflow:Assets written to: /content/drive/MyDrive/Research Assignment 4/LSTM_100_Dims_1_Layers_8_Units/assets

Word Embedding Dims: 300
LSTM Layers: 1
LSTM Units: 8
-----------------------
Accuracy: 0.8710557222366333
Precision: 0.9076350927352905
Recall: 0.8257023692131042
F1: 0.8647323015912494
Total Time (s): 53.86974763870239

Model Accuracy Trend
--------------------

Confusion Matrix
----------------

INFO:tensorflow:Assets written to: /content/drive/MyDrive/Research Assignment 4/LSTM_300_Dims_1_Layers_8_Units/assets

Word Embedding Dims: 500
LSTM Layers: 1
LSTM Units: 8
-----------------------
Accuracy: 0.8822230696678162
Precision: 0.8774093985557556
Recall: 0.8881373405456543
F1: 0.8827407766046249
Total Time (s): 80.31463885307312

Model Accuracy Trend
--------------------

Confusion Matrix
----------------

INFO:tensorflow:Assets written to: /content/drive/MyDrive/Research Assignment 4/LSTM_500_Dims_1_Layers_8_Units/assets

Word Embedding Dims: 100
LSTM Layers: 1
LSTM Units: 8
Bidirectional Layer(s)
-----------------------
Accuracy: 0.8115829229354858
Precision: 0.9572029113769531
Recall: 0.6516649127006531
F1: 0.7754217498095535
Total Time (s): 41.56441950798035

Model Accuracy Trend
--------------------

Confusion Matrix
----------------

INFO:tensorflow:Assets written to: /content/drive/MyDrive/Research Assignment 4/LSTM_100_Dims_1_Bidirectional_8_Units/assets

Word Embedding Dims: 300
LSTM Layers: 1
LSTM Units: 8
Bidirectional Layer(s)
-----------------------
Accuracy: 0.7843137383460999
Precision: 0.9642705321311951
Recall: 0.5897502899169922
F1: 0.7318805743326791
Total Time (s): 68.95310378074646

Model Accuracy Trend
--------------------

Confusion Matrix
----------------


lstm_results = pd.read_csv('/content/drive/MyDrive/Research Assignment 4/LSTM_Results.csv', header=0, index_col=0)
lstm_results.sort_values(by='Test F1',ascending=False).head()


model = keras.models.load_model('/content/drive/MyDrive/Research Assignment 4/LSTM_500_Dims_1_Layers_8_Units')

print('Model Summary')
print('-------------')
model.summary()

print('Confusion Matrix')
print('----------------')
pred_test = model.predict_classes(X_test_seq)

conf_matrix = tf.math.confusion_matrix(y_test, pred_test)

fig, ax = plt.subplots(figsize=(10,8))
ax = sns.heatmap(conf_matrix, annot=True, fmt='g')

ax.set_xlabel("Predicted Classes")
ax.set_ylabel("Actual Classes")
ax.set_xticklabels(['Negative','Positive'])
ax.set_yticklabels(['Negative','Positive'], va='center')
plt.show()
print()

Model Summary
-------------
Model: "sequential_2"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
embedding_2 (Embedding)      (None, 299, 500)          5000000   
_________________________________________________________________
lstm_2 (LSTM)                (None, 8)                 16288     
_________________________________________________________________
dense_2 (Dense)              (None, 1)                 9         
=================================================================
Total params: 5,016,297
Trainable params: 5,016,297
Non-trainable params: 0
_________________________________________________________________
Confusion Matrix
----------------


for LSTM_units in range(1,8):

  dims = 500
  LSTM_layers = 1
  num_epochs = 5

  start_time = time.time()

  print('Word Embedding Dims:',dims)
  print('LSTM Layers:',LSTM_layers)
  print('LSTM Units:',LSTM_units)
  print('-----------------------')

  seed(5)
  tf.random.set_seed(5)

  model = models.Sequential()
  model.add(Embedding(input_dim = voc_size, output_dim = dims, input_length = X_train_seq.shape[1]))          
  model.add(LSTM(units=LSTM_units))
  model.add(Dense(1, activation='sigmoid'))

  model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['Precision','Recall','accuracy'])

  history = model.fit(X_train_seq, y_train, batch_size=128, epochs=num_epochs, validation_split=0.2, verbose=False)

  total_time = time.time() - start_time

  loss, precision, recall, accuracy = model.evaluate(X_test_seq, y_test, verbose=0)

  f1_score = (2 * precision * recall) / (precision + recall)

  print('Accuracy:',accuracy)
  print('Precision:',precision)
  print('Recall:',recall)
  print('F1:',f1_score)
  print('Total Time (s):',total_time)
  print()

  acc = history.history['accuracy']
  val_acc = history.history['val_accuracy']
  loss = history.history['loss']
  val_loss = history.history['val_loss']

  print('Model Accuracy Trend')
  print('--------------------')
  plot = plt.plot(range(1, len(acc) + 1), history.history['accuracy'], label = 'Training')
  plot = plt.plot(range(1, len(val_acc) + 1), history.history['val_accuracy'], label = 'Validation')
  plot = plt.title('Training and Validation Accuracy')
  plot = plt.xlabel('Epochs')
  plot = plt.ylabel('Accuracy')
  plot = plt.legend()
  plt.show()
  print()

  print('Confusion Matrix')
  print('----------------')
  pred_test = model.predict_classes(X_test_seq)

  conf_matrix = tf.math.confusion_matrix(y_test, pred_test)

  fig, ax = plt.subplots(figsize=(10,8))
  ax = sns.heatmap(conf_matrix, annot=True, fmt='g')

  ax.set_xlabel("Predicted Classes")
  ax.set_ylabel("Actual Classes")
  ax.set_xticklabels(['Negative','Positive'])
  ax.set_yticklabels(['Negative','Positive'], va='center')
  plt.show()
  print()

  model_name = 'LSTM_{}_Dims_{}_Layers_{}_Units'.format(dims,LSTM_layers,LSTM_units)

  model.save('/content/drive/MyDrive/Research Assignment 4/'+model_name)
  print()

  lstm_results = lstm_results.append(
      {'Model':model_name,
        'Embed_Dims':dims,
        'LSTM Layers':LSTM_layers,
        'LSTM Units':LSTM_units,
        'Bidirectional':0,
        'Epochs':num_epochs,
        'Time':total_time,
        'Test Accuracy':accuracy,
        'Test Precision':precision,
        'Test Recall':recall,
        'Test F1':f1_score
      }, ignore_index=True)
  
  lstm_results.to_csv('/content/drive/MyDrive/Research Assignment 4/'+'LSTM_Results.csv')

Word Embedding Dims: 500
LSTM Layers: 1
LSTM Units: 1
-----------------------
Accuracy: 0.8726139664649963
Precision: 0.8940269947052002
Recall: 0.844953179359436
F1: 0.8687976583926743
Total Time (s): 90.40184187889099

Model Accuracy Trend
--------------------

Confusion Matrix
----------------

WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/tensorflow/python/training/tracking/tracking.py:111: Model.state_updates (from tensorflow.python.keras.engine.training) is deprecated and will be removed in a future version.
Instructions for updating:
This property should not be used in TensorFlow 2.0, as updates are applied automatically.
WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/tensorflow/python/training/tracking/tracking.py:111: Layer.updates (from tensorflow.python.keras.engine.base_layer) is deprecated and will be removed in a future version.
Instructions for updating:
This property should not be used in TensorFlow 2.0, as updates are applied automatically.
INFO:tensorflow:Assets written to: /content/drive/MyDrive/Research Assignment 4/LSTM_500_Dims_1_Layers_1_Units/assets

Word Embedding Dims: 500
LSTM Layers: 1
LSTM Units: 2
-----------------------
Accuracy: 0.8669003844261169
Precision: 0.9163958430290222
Recall: 0.8069719076156616
F1: 0.8582099802013301
Total Time (s): 92.48079991340637

Model Accuracy Trend
--------------------

Confusion Matrix
----------------

INFO:tensorflow:Assets written to: /content/drive/MyDrive/Research Assignment 4/LSTM_500_Dims_1_Layers_2_Units/assets

Word Embedding Dims: 500
LSTM Layers: 1
LSTM Units: 3
-----------------------
Accuracy: 0.8423581123352051
Precision: 0.9305828213691711
Recall: 0.7393340468406677
F1: 0.824006962670936
Total Time (s): 92.67104625701904

Model Accuracy Trend
--------------------

Confusion Matrix
----------------

INFO:tensorflow:Assets written to: /content/drive/MyDrive/Research Assignment 4/LSTM_500_Dims_1_Layers_3_Units/assets

Word Embedding Dims: 500
LSTM Layers: 1
LSTM Units: 4
-----------------------
Accuracy: 0.8706661462783813
Precision: 0.9033994078636169
Recall: 0.8296045660972595
F1: 0.8649308195875339
Total Time (s): 93.85107207298279

Model Accuracy Trend
--------------------

Confusion Matrix
----------------

INFO:tensorflow:Assets written to: /content/drive/MyDrive/Research Assignment 4/LSTM_500_Dims_1_Layers_4_Units/assets

Word Embedding Dims: 500
LSTM Layers: 1
LSTM Units: 5
-----------------------
Accuracy: 0.877937912940979
Precision: 0.898463249206543
Recall: 0.851716935634613
F1: 0.8744658087463906
Total Time (s): 90.83017182350159

Model Accuracy Trend
--------------------

Confusion Matrix
----------------


for dims in [1,2,4,8,16,32,64]:
  
  #dims = 500
  LSTM_units = 8
  LSTM_layers = 1
  num_epochs = 5

  start_time = time.time()

  print('Word Embedding Dims:',dims)
  print('LSTM Layers:',LSTM_layers)
  print('LSTM Units:',LSTM_units)
  print('-----------------------')

  seed(5)
  tf.random.set_seed(5)

  model = models.Sequential()
  model.add(Embedding(input_dim = voc_size, output_dim = dims, input_length = X_train_seq.shape[1]))          
  model.add(LSTM(units=LSTM_units))
  model.add(Dense(1, activation='sigmoid'))

  model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['Precision','Recall','accuracy'])

  history = model.fit(X_train_seq, y_train, batch_size=128, epochs=num_epochs, validation_split=0.2, verbose=False)

  total_time = time.time() - start_time

  loss, precision, recall, accuracy = model.evaluate(X_test_seq, y_test, verbose=0)

  f1_score = (2 * precision * recall) / (precision + recall)

  print('Accuracy:',accuracy)
  print('Precision:',precision)
  print('Recall:',recall)
  print('F1:',f1_score)
  print('Total Time (s):',total_time)
  print()

  acc = history.history['accuracy']
  val_acc = history.history['val_accuracy']
  loss = history.history['loss']
  val_loss = history.history['val_loss']

  print('Model Accuracy Trend')
  print('--------------------')
  plot = plt.plot(range(1, len(acc) + 1), history.history['accuracy'], label = 'Training')
  plot = plt.plot(range(1, len(val_acc) + 1), history.history['val_accuracy'], label = 'Validation')
  plot = plt.title('Training and Validation Accuracy')
  plot = plt.xlabel('Epochs')
  plot = plt.ylabel('Accuracy')
  plot = plt.legend()
  plt.show()
  print()

  print('Confusion Matrix')
  print('----------------')
  pred_test = model.predict_classes(X_test_seq)

  conf_matrix = tf.math.confusion_matrix(y_test, pred_test)

  fig, ax = plt.subplots(figsize=(10,8))
  ax = sns.heatmap(conf_matrix, annot=True, fmt='g')

  ax.set_xlabel("Predicted Classes")
  ax.set_ylabel("Actual Classes")
  ax.set_xticklabels(['Negative','Positive'])
  ax.set_yticklabels(['Negative','Positive'], va='center')
  plt.show()
  print()

  model_name = 'LSTM_{}_Dims_{}_Layers_{}_Units'.format(dims,LSTM_layers,LSTM_units)

  model.save('/content/drive/MyDrive/Research Assignment 4/'+model_name)
  print()

  lstm_results = lstm_results.append(
      {'Model':model_name,
        'Embed_Dims':dims,
        'LSTM Layers':LSTM_layers,
        'LSTM Units':LSTM_units,
        'Bidirectional':0,
        'Epochs':num_epochs,
        'Time':total_time,
        'Test Accuracy':accuracy,
        'Test Precision':precision,
        'Test Recall':recall,
        'Test F1':f1_score
      }, ignore_index=True)
  
  lstm_results.to_csv('/content/drive/MyDrive/Research Assignment 4/'+'LSTM_Results.csv')

Word Embedding Dims: 1
LSTM Layers: 1
LSTM Units: 8
-----------------------
Accuracy: 0.854174792766571
Precision: 0.8510967493057251
Recall: 0.8579604625701904
F1: 0.8545148233215979
Total Time (s): 19.711127996444702

Model Accuracy Trend
--------------------

Confusion Matrix
----------------

INFO:tensorflow:Assets written to: /content/drive/MyDrive/Research Assignment 4/LSTM_1_Dims_1_Layers_8_Units/assets

Word Embedding Dims: 2
LSTM Layers: 1
LSTM Units: 8
-----------------------
Accuracy: 0.8768991231918335
Precision: 0.8523114323616028
Recall: 0.9112903475761414
F1: 0.8808146944230708
Total Time (s): 20.338643074035645

Model Accuracy Trend
--------------------

Confusion Matrix
----------------

INFO:tensorflow:Assets written to: /content/drive/MyDrive/Research Assignment 4/LSTM_2_Dims_1_Layers_8_Units/assets

Word Embedding Dims: 4
LSTM Layers: 1
LSTM Units: 8
-----------------------
Accuracy: 0.8732632398605347
Precision: 0.8809776902198792
Recall: 0.8626430630683899
F1: 0.8717139799500283
Total Time (s): 19.81888699531555

Model Accuracy Trend
--------------------

Confusion Matrix
----------------

INFO:tensorflow:Assets written to: /content/drive/MyDrive/Research Assignment 4/LSTM_4_Dims_1_Layers_8_Units/assets

Word Embedding Dims: 8
LSTM Layers: 1
LSTM Units: 8
-----------------------
Accuracy: 0.8804051280021667
Precision: 0.9083542823791504
Recall: 0.8457335829734802
F1: 0.8759261574292735
Total Time (s): 20.031910181045532

Model Accuracy Trend
--------------------

Confusion Matrix
----------------

INFO:tensorflow:Assets written to: /content/drive/MyDrive/Research Assignment 4/LSTM_8_Dims_1_Layers_8_Units/assets

Word Embedding Dims: 16
LSTM Layers: 1
LSTM Units: 8
-----------------------
Accuracy: 0.85300612449646
Precision: 0.938551127910614
Recall: 0.754942774772644
F1: 0.8367935563844277
Total Time (s): 20.876673460006714

Model Accuracy Trend
--------------------

Confusion Matrix
----------------


lstm_results = pd.read_csv('/content/drive/MyDrive/Research Assignment 4/LSTM_Results.csv', header=0, index_col=0)
lstm_results.sort_values(by='Test F1',ascending=False).head()


plot_df = lstm_results[['Embed_Dims','LSTM Layers','LSTM Units','Bidirectional','Test F1']]

fig, ax = plt.subplots(3,1,figsize=(12,12))

sns.lineplot(x='Embed_Dims',y='Test F1',data=plot_df,hue='Bidirectional',ax=ax[0])
sns.lineplot(x='LSTM Layers',y='Test F1',data=plot_df,hue='Bidirectional',ax=ax[1])
sns.lineplot(x='LSTM Units',y='Test F1',data=plot_df,hue='Bidirectional',ax=ax[2])

<matplotlib.axes._subplots.AxesSubplot at 0x7f5daa85e6a0>


gru_results = pd.DataFrame(columns=['Model','Embed_Dims','GRU Layers','GRU Units','Bidirectional','Epochs','Time','Test Accuracy','Test Precision','Test Recall','Test F1'])

for GRU_units in [8,16,32,64]:
    
    for GRU_layers in [1,2,3]:

        for bidirectional in [0,1]:
    
            for embed_dims in [100,300,500]:

                dims = embed_dims

                num_epochs = 5

                start_time = time.time()

                print('Word Embedding Dims:',dims)
                print('GRU Layers:',GRU_layers)
                print('GRU Units:',GRU_units)
                if bidirectional == 1:
                  print('Bidirectional Layer(s)')
                print('-----------------------')

                seed(5)
                tf.random.set_seed(5)

                model = models.Sequential()
                model.add(Embedding(input_dim = voc_size, output_dim = dims, input_length = X_train_seq.shape[1]))
                
                if GRU_layers > 1:
                    
                    for layers in range(1,GRU_layers):
                        
                        if bidirectional == 1:
                          model.add(Bidirectional(GRU(units=GRU_units, return_sequences=True)))
                        else:
                          model.add(GRU(units=GRU_units, return_sequences=True))

                if bidirectional == 1:   
                    model.add(Bidirectional(GRU(units=GRU_units)))
                else:    
                    model.add(GRU(units=GRU_units))

                model.add(Dense(1, activation='sigmoid'))

                model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['Precision','Recall','accuracy'])

                history = model.fit(X_train_seq, y_train, batch_size=128, epochs=num_epochs, validation_split=0.2, verbose=False)

                total_time = time.time() - start_time

                loss, precision, recall, accuracy = model.evaluate(X_test_seq, y_test, verbose=0)

                f1_score = (2 * precision * recall) / (precision + recall)

                print('Accuracy:',accuracy)
                print('Precision:',precision)
                print('Recall:',recall)
                print('F1:',f1_score)
                print('Total Time (s):',total_time)
                print()

                acc = history.history['accuracy']
                val_acc = history.history['val_accuracy']
                loss = history.history['loss']
                val_loss = history.history['val_loss']

                print('Model Accuracy Trend')
                print('--------------------')
                plot = plt.plot(range(1, len(acc) + 1), history.history['accuracy'], label = 'Training')
                plot = plt.plot(range(1, len(val_acc) + 1), history.history['val_accuracy'], label = 'Validation')
                plot = plt.title('Training and Validation Accuracy')
                plot = plt.xlabel('Epochs')
                plot = plt.ylabel('Accuracy')
                plot = plt.legend()
                plt.show()
                print()

                print('Confusion Matrix')
                print('----------------')
                pred_test = model.predict_classes(X_test_seq)

                conf_matrix = tf.math.confusion_matrix(y_test, pred_test)

                fig, ax = plt.subplots(figsize=(10,8))
                ax = sns.heatmap(conf_matrix, annot=True, fmt='g')

                ax.set_xlabel("Predicted Classes")
                ax.set_ylabel("Actual Classes")
                ax.set_xticklabels(['Negative','Positive'])
                ax.set_yticklabels(['Negative','Positive'], va='center')
                plt.show()
                print()

                if bidirectional == 1:
                    model_name = 'GRU_{}_Dims_{}_Bidirectional_{}_Units'.format(embed_dims,GRU_layers,GRU_units)

                else:
                    model_name = 'GRU_{}_Dims_{}_Layers_{}_Units'.format(embed_dims,GRU_layers,GRU_units)

                model.save('/content/drive/MyDrive/Research Assignment 4/'+model_name)
                print()

                gru_results = gru_results.append(
                    {'Model':model_name,
                    'Embed_Dims':dims,
                    'GRU Layers':GRU_layers,
                    'GRU Units':GRU_units,
                    'Bidirectional':bidirectional,
                    'Epochs':num_epochs,
                    'Time':total_time,
                    'Test Accuracy':accuracy,
                    'Test Precision':precision,
                    'Test Recall':recall,
                    'Test F1':f1_score
                    }, ignore_index=True)
                
                gru_results.to_csv('/content/drive/MyDrive/Research Assignment 4/'+'GRU_Results.csv')

Word Embedding Dims: 100
GRU Layers: 1
GRU Units: 8
-----------------------
Accuracy: 0.8380729556083679
Precision: 0.940617561340332
Recall: 0.7211238145828247
F1: 0.8163745980273416
Total Time (s): 33.38325619697571

Model Accuracy Trend
--------------------

Confusion Matrix
----------------
WARNING:tensorflow:From <ipython-input-13-bb44762ee54e>:81: Sequential.predict_classes (from tensorflow.python.keras.engine.sequential) is deprecated and will be removed after 2021-01-01.
Instructions for updating:
Please use instead:* `np.argmax(model.predict(x), axis=-1)`,   if your model does multi-class classification   (e.g. if it uses a `softmax` last-layer activation).* `(model.predict(x) > 0.5).astype("int32")`,   if your model does binary classification   (e.g. if it uses a `sigmoid` last-layer activation).

WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/tensorflow/python/training/tracking/tracking.py:111: Model.state_updates (from tensorflow.python.keras.engine.training) is deprecated and will be removed in a future version.
Instructions for updating:
This property should not be used in TensorFlow 2.0, as updates are applied automatically.
WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/tensorflow/python/training/tracking/tracking.py:111: Layer.updates (from tensorflow.python.keras.engine.base_layer) is deprecated and will be removed in a future version.
Instructions for updating:
This property should not be used in TensorFlow 2.0, as updates are applied automatically.
INFO:tensorflow:Assets written to: /content/drive/MyDrive/Research Assignment 4/GRU_100_Dims_1_Layers_8_Units/assets

Word Embedding Dims: 300
GRU Layers: 1
GRU Units: 8
-----------------------
Accuracy: 0.8592390418052673
Precision: 0.932330846786499
Recall: 0.774193525314331
F1: 0.8459351847924118
Total Time (s): 50.76484704017639

Model Accuracy Trend
--------------------

Confusion Matrix
----------------

INFO:tensorflow:Assets written to: /content/drive/MyDrive/Research Assignment 4/GRU_300_Dims_1_Layers_8_Units/assets

Word Embedding Dims: 500
GRU Layers: 1
GRU Units: 8
-----------------------
Accuracy: 0.860537588596344
Precision: 0.9290582537651062
Recall: 0.7801768779754639
F1: 0.8481334772725844
Total Time (s): 75.52616930007935

Model Accuracy Trend
--------------------

Confusion Matrix
----------------

INFO:tensorflow:Assets written to: /content/drive/MyDrive/Research Assignment 4/GRU_500_Dims_1_Layers_8_Units/assets

Word Embedding Dims: 100
GRU Layers: 1
GRU Units: 8
Bidirectional Layer(s)
-----------------------
Accuracy: 0.8141799569129944
Precision: 0.936663031578064
Recall: 0.673257052898407
F1: 0.7834115472932983
Total Time (s): 38.65559530258179

Model Accuracy Trend
--------------------

Confusion Matrix
----------------

INFO:tensorflow:Assets written to: /content/drive/MyDrive/Research Assignment 4/GRU_100_Dims_1_Bidirectional_8_Units/assets

Word Embedding Dims: 300
GRU Layers: 1
GRU Units: 8
Bidirectional Layer(s)
-----------------------
Accuracy: 0.8722243905067444
Precision: 0.9208357930183411
Recall: 0.8139958381652832
F1: 0.8641259355401049
Total Time (s): 64.00441360473633

Model Accuracy Trend
--------------------

Confusion Matrix
----------------


top_gru = gru_results.sort_values(by='Test F1',ascending=False).head().reset_index(drop=True).iloc[0]


model = keras.models.load_model('/content/drive/MyDrive/Research Assignment 4/{}'.format(top_gru['Model']))

print('Model Summary')
print('-------------')
model.summary()

print('Confusion Matrix')
print('----------------')
pred_test = model.predict_classes(X_test_seq)

conf_matrix = tf.math.confusion_matrix(y_test, pred_test)

fig, ax = plt.subplots(figsize=(10,8))
ax = sns.heatmap(conf_matrix, annot=True, fmt='g')

ax.set_xlabel("Predicted Classes")
ax.set_ylabel("Actual Classes")
ax.set_xticklabels(['Negative','Positive'])
ax.set_yticklabels(['Negative','Positive'], va='center')
plt.show()
print()

Model Summary
-------------
Model: "sequential_6"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
embedding_5 (Embedding)      (None, 299, 500)          5000000   
_________________________________________________________________
bidirectional_2 (Bidirection (None, 16)                24480     
_________________________________________________________________
dense_5 (Dense)              (None, 1)                 17        
=================================================================
Total params: 5,024,497
Trainable params: 5,024,497
Non-trainable params: 0
_________________________________________________________________
Confusion Matrix
----------------


for GRU_units in range(1,top_gru['GRU Units']):

  dims = top_gru['Embed_Dims']
  GRU_layers = top_gru['GRU Layers']
  bidirectional = top_gru['Bidirectional']
  num_epochs = 5

  start_time = time.time()

  print('Word Embedding Dims:',dims)
  print('GRU Layers:',GRU_layers)
  print('GRU Units:',GRU_units)
  print('-----------------------')

  seed(5)
  tf.random.set_seed(5)

  model = models.Sequential()
  model.add(Embedding(input_dim = voc_size, output_dim = dims, input_length = X_train_seq.shape[1]))

  if GRU_layers > 1:
                    
    for layers in range(1,GRU_layers):
      
      if bidirectional == 1:
        model.add(Bidirectional(GRU(units=GRU_units, return_sequences=True)))
      else:
        model.add(GRU(units=GRU_units, return_sequences=True))

  if bidirectional == 1:   
      model.add(Bidirectional(GRU(units=GRU_units)))
  else:    
      model.add(GRU(units=GRU_units))

  model.add(Dense(1, activation='sigmoid'))

  model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['Precision','Recall','accuracy'])

  history = model.fit(X_train_seq, y_train, batch_size=128, epochs=num_epochs, validation_split=0.2, verbose=False)

  total_time = time.time() - start_time

  loss, precision, recall, accuracy = model.evaluate(X_test_seq, y_test, verbose=0)

  f1_score = (2 * precision * recall) / (precision + recall)

  print('Accuracy:',accuracy)
  print('Precision:',precision)
  print('Recall:',recall)
  print('F1:',f1_score)
  print('Total Time (s):',total_time)
  print()

  acc = history.history['accuracy']
  val_acc = history.history['val_accuracy']
  loss = history.history['loss']
  val_loss = history.history['val_loss']

  print('Model Accuracy Trend')
  print('--------------------')
  plot = plt.plot(range(1, len(acc) + 1), history.history['accuracy'], label = 'Training')
  plot = plt.plot(range(1, len(val_acc) + 1), history.history['val_accuracy'], label = 'Validation')
  plot = plt.title('Training and Validation Accuracy')
  plot = plt.xlabel('Epochs')
  plot = plt.ylabel('Accuracy')
  plot = plt.legend()
  plt.show()
  print()

  print('Confusion Matrix')
  print('----------------')
  pred_test = model.predict_classes(X_test_seq)

  conf_matrix = tf.math.confusion_matrix(y_test, pred_test)

  fig, ax = plt.subplots(figsize=(10,8))
  ax = sns.heatmap(conf_matrix, annot=True, fmt='g')

  ax.set_xlabel("Predicted Classes")
  ax.set_ylabel("Actual Classes")
  ax.set_xticklabels(['Negative','Positive'])
  ax.set_yticklabels(['Negative','Positive'], va='center')
  plt.show()
  print()

  if bidirectional == 1:   
      model_name = 'GRU_{}_Dims_{}_Bidirectional_{}_Units'.format(dims,GRU_layers,GRU_units)
  else:    
      model_name = 'GRU_{}_Dims_{}_Layers_{}_Units'.format(dims,GRU_layers,GRU_units)

  model.save('/content/drive/MyDrive/Research Assignment 4/'+model_name)
  print()

  gru_results = gru_results.append(
      {'Model':model_name,
        'Embed_Dims':dims,
        'GRU Layers':GRU_layers,
        'GRU Units':GRU_units,
        'Bidirectional':bidirectional,
        'Epochs':num_epochs,
        'Time':total_time,
        'Test Accuracy':accuracy,
        'Test Precision':precision,
        'Test Recall':recall,
        'Test F1':f1_score
      }, ignore_index=True)
  
  gru_results.to_csv('/content/drive/MyDrive/Research Assignment 4/'+'GRU_Results.csv')

Word Embedding Dims: 500
GRU Layers: 1
GRU Units: 1
-----------------------
Accuracy: 0.7436696290969849
Precision: 0.7343358397483826
Recall: 0.7622268199920654
F1: 0.7480214320390539
Total Time (s): 92.85933899879456

Model Accuracy Trend
--------------------

Confusion Matrix
----------------

INFO:tensorflow:Assets written to: /content/drive/MyDrive/Research Assignment 4/GRU_500_Dims_1_Bidirectional_1_Units/assets

Word Embedding Dims: 500
GRU Layers: 1
GRU Units: 2
-----------------------
Accuracy: 0.7786001563072205
Precision: 0.7932547330856323
Recall: 0.7526014447212219
F1: 0.7723935340468477
Total Time (s): 92.87485575675964

Model Accuracy Trend
--------------------

Confusion Matrix
----------------

INFO:tensorflow:Assets written to: /content/drive/MyDrive/Research Assignment 4/GRU_500_Dims_1_Bidirectional_2_Units/assets

Word Embedding Dims: 500
GRU Layers: 1
GRU Units: 3
-----------------------
Accuracy: 0.8559927344322205
Precision: 0.8665237426757812
Recall: 0.8410509824752808
F1: 0.8535973675191874
Total Time (s): 92.79370069503784

Model Accuracy Trend
--------------------

Confusion Matrix
----------------

INFO:tensorflow:Assets written to: /content/drive/MyDrive/Research Assignment 4/GRU_500_Dims_1_Bidirectional_3_Units/assets

Word Embedding Dims: 500
GRU Layers: 1
GRU Units: 4
-----------------------
Accuracy: 0.8656018972396851
Precision: 0.8928671479225159
Recall: 0.8303850293159485
F1: 0.8604933422930905
Total Time (s): 93.92228078842163

Model Accuracy Trend
--------------------

Confusion Matrix
----------------

INFO:tensorflow:Assets written to: /content/drive/MyDrive/Research Assignment 4/GRU_500_Dims_1_Bidirectional_4_Units/assets

Word Embedding Dims: 500
GRU Layers: 1
GRU Units: 5
-----------------------
Accuracy: 0.8574211001396179
Precision: 0.914553165435791
Recall: 0.7879812717437744
F1: 0.8465623374658148
Total Time (s): 91.42268514633179

Model Accuracy Trend
--------------------

Confusion Matrix
----------------


for dims in [1,2,4,8,16,32,64]:

  GRU_units = top_gru['GRU Units']
  GRU_layers = top_gru['GRU Layers']
  bidirectional = top_gru['Bidirectional']
  num_epochs = 5

  start_time = time.time()

  print('Word Embedding Dims:',dims)
  print('GRU Layers:',GRU_layers)
  print('GRU Units:',GRU_units)
  print('-----------------------')

  seed(5)
  tf.random.set_seed(5)

  model = models.Sequential()
  model.add(Embedding(input_dim = voc_size, output_dim = dims, input_length = X_train_seq.shape[1]))

  if GRU_layers > 1:
                    
    for layers in range(1,GRU_layers):
      
      if bidirectional == 1:
        model.add(Bidirectional(GRU(units=GRU_units, return_sequences=True)))
      else:
        model.add(GRU(units=GRU_units, return_sequences=True))

  if bidirectional == 1:   
      model.add(Bidirectional(GRU(units=GRU_units)))
  else:    
      model.add(GRU(units=GRU_units))

  model.add(Dense(1, activation='sigmoid'))

  model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['Precision','Recall','accuracy'])

  history = model.fit(X_train_seq, y_train, batch_size=128, epochs=num_epochs, validation_split=0.2, verbose=False)

  total_time = time.time() - start_time

  loss, precision, recall, accuracy = model.evaluate(X_test_seq, y_test, verbose=0)

  f1_score = (2 * precision * recall) / (precision + recall)

  print('Accuracy:',accuracy)
  print('Precision:',precision)
  print('Recall:',recall)
  print('F1:',f1_score)
  print('Total Time (s):',total_time)
  print()

  acc = history.history['accuracy']
  val_acc = history.history['val_accuracy']
  loss = history.history['loss']
  val_loss = history.history['val_loss']

  print('Model Accuracy Trend')
  print('--------------------')
  plot = plt.plot(range(1, len(acc) + 1), history.history['accuracy'], label = 'Training')
  plot = plt.plot(range(1, len(val_acc) + 1), history.history['val_accuracy'], label = 'Validation')
  plot = plt.title('Training and Validation Accuracy')
  plot = plt.xlabel('Epochs')
  plot = plt.ylabel('Accuracy')
  plot = plt.legend()
  plt.show()
  print()

  print('Confusion Matrix')
  print('----------------')
  pred_test = model.predict_classes(X_test_seq)

  conf_matrix = tf.math.confusion_matrix(y_test, pred_test)

  fig, ax = plt.subplots(figsize=(10,8))
  ax = sns.heatmap(conf_matrix, annot=True, fmt='g')

  ax.set_xlabel("Predicted Classes")
  ax.set_ylabel("Actual Classes")
  ax.set_xticklabels(['Negative','Positive'])
  ax.set_yticklabels(['Negative','Positive'], va='center')
  plt.show()
  print()

  if bidirectional == 1:   
      model_name = 'GRU_{}_Dims_{}_Bidirectional_{}_Units'.format(dims,GRU_layers,GRU_units)
  else:    
      model_name = 'GRU_{}_Dims_{}_Layers_{}_Units'.format(dims,GRU_layers,GRU_units)

  model.save('/content/drive/MyDrive/Research Assignment 4/'+model_name)
  print()

  gru_results = gru_results.append(
      {'Model':model_name,
        'Embed_Dims':dims,
        'GRU Layers':GRU_layers,
        'GRU Units':GRU_units,
        'Bidirectional':bidirectional,
        'Epochs':num_epochs,
        'Time':total_time,
        'Test Accuracy':accuracy,
        'Test Precision':precision,
        'Test Recall':recall,
        'Test F1':f1_score
      }, ignore_index=True)
  
  gru_results.to_csv('/content/drive/MyDrive/Research Assignment 4/'+'GRU_Results.csv')

Word Embedding Dims: 1
GRU Layers: 1
GRU Units: 8
-----------------------
Accuracy: 0.8549538850784302
Precision: 0.8253400325775146
Recall: 0.8998439311981201
F1: 0.8609832169600699
Total Time (s): 29.227556705474854

Model Accuracy Trend
--------------------

Confusion Matrix
----------------

INFO:tensorflow:Assets written to: /content/drive/MyDrive/Research Assignment 4/GRU_1_Dims_1_Bidirectional_8_Units/assets

Word Embedding Dims: 2
GRU Layers: 1
GRU Units: 8
-----------------------
Accuracy: 0.8532658219337463
Precision: 0.9180529713630676
Recall: 0.7752341032028198
F1: 0.8406205688776001
Total Time (s): 29.236473083496094

Model Accuracy Trend
--------------------

Confusion Matrix
----------------

INFO:tensorflow:Assets written to: /content/drive/MyDrive/Research Assignment 4/GRU_2_Dims_1_Bidirectional_8_Units/assets

Word Embedding Dims: 4
GRU Layers: 1
GRU Units: 8
-----------------------
Accuracy: 0.8092455267906189
Precision: 0.9419426918029785
Recall: 0.6584287285804749
F1: 0.7750727375660121
Total Time (s): 29.43592143058777

Model Accuracy Trend
--------------------

Confusion Matrix
----------------

INFO:tensorflow:Assets written to: /content/drive/MyDrive/Research Assignment 4/GRU_4_Dims_1_Bidirectional_8_Units/assets

Word Embedding Dims: 8
GRU Layers: 1
GRU Units: 8
-----------------------
Accuracy: 0.8683288097381592
Precision: 0.9024459719657898
Recall: 0.8254422545433044
F1: 0.862228269484704
Total Time (s): 29.588261127471924

Model Accuracy Trend
--------------------

Confusion Matrix
----------------

INFO:tensorflow:Assets written to: /content/drive/MyDrive/Research Assignment 4/GRU_8_Dims_1_Bidirectional_8_Units/assets

Word Embedding Dims: 16
GRU Layers: 1
GRU Units: 8
-----------------------
Accuracy: 0.8453447818756104
Precision: 0.9131112098693848
Recall: 0.7627471089363098
F1: 0.8311835525112323
Total Time (s): 30.114232778549194

Model Accuracy Trend
--------------------

Confusion Matrix
----------------


gru_results = pd.read_csv('/content/drive/MyDrive/Research Assignment 4/GRU_Results.csv', header=0, index_col=0)
gru_results.sort_values(by='Test F1',ascending=False).head()


plot_df = gru_results[['Embed_Dims','GRU Layers','GRU Units','Bidirectional','Test F1']]

fig, ax = plt.subplots(3,1,figsize=(12,12))

sns.lineplot(x='Embed_Dims',y='Test F1',data=plot_df,hue='Bidirectional',ax=ax[0])
sns.lineplot(x='GRU Layers',y='Test F1',data=plot_df,hue='Bidirectional',ax=ax[1])
sns.lineplot(x='GRU Units',y='Test F1',data=plot_df,hue='Bidirectional',ax=ax[2])

<matplotlib.axes._subplots.AxesSubplot at 0x7f9ecfd08240>


rnn_results = pd.read_csv('/content/drive/MyDrive/Research Assignment 4/RNN_Results.csv', header=0, index_col=0)
lstm_results = pd.read_csv('/content/drive/MyDrive/Research Assignment 4/LSTM_Results.csv', header=0, index_col=0)
gru_results = pd.read_csv('/content/drive/MyDrive/Research Assignment 4/GRU_Results.csv', header=0, index_col=0)

rnn_results = rnn_results.rename(columns={'RNN Layers':'Layers','RNN Units':'Units'})
lstm_results = lstm_results.rename(columns={'LSTM Layers':'Layers','LSTM Units':'Units'})
gru_results = gru_results.rename(columns={'GRU Layers':'Layers','GRU Units':'Units'})

results = rnn_results.append(lstm_results,ignore_index=True).append(gru_results,ignore_index=True)
results['Type'] = results['Model'].apply(lambda x: x.split('_')[0])

results.head(25)


plot_df = results[['Type','Embed_Dims','Layers','Units','Bidirectional','Test F1']]

fig, ax = plt.subplots(3,2,figsize=(20,12))

sns.lineplot(x='Embed_Dims',y='Test F1',data=plot_df[plot_df['Bidirectional']==0],hue='Type',ax=ax[0,0])
sns.lineplot(x='Embed_Dims',y='Test F1',data=plot_df[plot_df['Bidirectional']==1],hue='Type',ax=ax[0,1])
sns.lineplot(x='Layers',y='Test F1',data=plot_df[plot_df['Bidirectional']==0],hue='Type',ax=ax[1,0])
sns.lineplot(x='Layers',y='Test F1',data=plot_df[plot_df['Bidirectional']==1],hue='Type',ax=ax[1,1])
sns.lineplot(x='Units',y='Test F1',data=plot_df[plot_df['Bidirectional']==0],hue='Type',ax=ax[2,0])
sns.lineplot(x='Units',y='Test F1',data=plot_df[plot_df['Bidirectional']==1],hue='Type',ax=ax[2,1])

<matplotlib.axes._subplots.AxesSubplot at 0x7f2e91375cf8>


results


results.sort_values(by='Test F1',ascending=False).head(15)


results.sort_values(by=['Type','Embed_Dims','Layers','Bidirectional','Units']).to_csv('/content/drive/MyDrive/Research Assignment 4/Results.csv')


results.sort_values(by='Test Accuracy',ascending=False)


results.sort_values(by='Test F1',ascending=False)[['Type','Embed_Dims','Layers','Units','Bidirectional','Epochs','Time','Test Accuracy','Test Precision','Test Recall','Test F1']].head(25)


results.groupby(by=['Type','Bidirectional'])[['Bidirectional','Time','Test Accuracy','Test Precision','Test Recall','Test F1']].mean()

	Model	Embed_Dims	GRU Layers	GRU Units	Bidirectional	Epochs	Time	Test Accuracy	Test Precision	Test Recall	Test F1
5	GRU_500_Dims_1_Bidirectional_8_Units	500	1	8	1	5	89.673430	0.884301	0.901550	0.862383	0.881532
55	GRU_300_Dims_1_Layers_64_Units	300	1	64	0	5	52.646481	0.884431	0.906663	0.856660	0.880952
11	GRU_500_Dims_2_Bidirectional_8_Units	500	2	8	1	5	115.990555	0.884560	0.917255	0.844953	0.879621
67	GRU_300_Dims_3_Layers_64_Units	300	3	64	0	5	78.039325	0.883262	0.914438	0.845213	0.878464
56	GRU_500_Dims_1_Layers_64_Units	500	1	64	0	5	79.279962	0.883262	0.915374	0.844173	0.878333

	Model	Embed_Dims	Layers	Units	Epochs	Bidirectional	Time	Test Accuracy	Test Precision	Test Recall	Test F1	Type
0	RNN_100_Dims_1_Layers_8_Units	100	1	8	5	0	298.059914	0.833009	0.898691	0.750000	0.817640	RNN
1	RNN_300_Dims_1_Layers_8_Units	300	1	8	5	0	327.749509	0.835865	0.893773	0.761707	0.822472	RNN
2	RNN_500_Dims_1_Layers_8_Units	500	1	8	5	0	357.598534	0.827035	0.859473	0.781217	0.818479	RNN
3	RNN_100_Dims_1_Bidirectional_8_Units	100	1	8	5	1	534.179945	0.840410	0.883994	0.783038	0.830459	RNN
4	RNN_300_Dims_1_Bidirectional_8_Units	300	1	8	5	1	556.481392	0.844436	0.867500	0.812435	0.839065	RNN
5	RNN_500_Dims_1_Bidirectional_8_Units	500	1	8	5	1	576.209012	0.824828	0.804789	0.856920	0.830037	RNN
6	RNN_100_Dims_2_Layers_8_Units	100	2	8	5	0	538.463594	0.821452	0.882791	0.740635	0.805489	RNN
7	RNN_300_Dims_2_Layers_8_Units	300	2	8	5	0	569.906159	0.789897	0.891626	0.659209	0.758002	RNN
8	RNN_500_Dims_2_Layers_8_Units	500	2	8	5	0	613.104590	0.765745	0.713478	0.886837	0.790768	RNN
9	RNN_100_Dims_2_Bidirectional_8_Units	100	2	8	5	1	1038.772605	0.823140	0.925291	0.702393	0.798580	RNN
10	RNN_300_Dims_2_Bidirectional_8_Units	300	2	8	5	1	1066.870519	0.806648	0.870399	0.719823	0.787982	RNN
11	RNN_500_Dims_2_Bidirectional_8_Units	500	2	8	5	1	1103.756692	0.806389	0.847768	0.746098	0.793690	RNN
12	RNN_100_Dims_3_Layers_8_Units	100	3	8	5	0	829.678187	0.789508	0.890411	0.659469	0.757734	RNN
13	RNN_300_Dims_3_Layers_8_Units	300	3	8	5	0	859.228556	0.784963	0.898688	0.641519	0.748634	RNN
14	RNN_500_Dims_3_Layers_8_Units	500	3	8	5	0	894.261376	0.830671	0.865362	0.782518	0.821858	RNN
15	RNN_100_Dims_3_Bidirectional_8_Units	100	3	8	5	1	1555.988676	0.844825	0.853294	0.832206	0.842618	RNN
16	RNN_300_Dims_3_Bidirectional_8_Units	300	3	8	5	1	1577.999882	0.832359	0.835480	0.827003	0.831220	RNN
17	RNN_500_Dims_3_Bidirectional_8_Units	500	3	8	5	1	1603.120622	0.790157	0.858430	0.694069	0.767549	RNN
18	RNN_100_Dims_1_Layers_16_Units	100	1	16	5	0	301.475875	0.762758	0.911129	0.581426	0.709862	RNN
19	RNN_300_Dims_1_Layers_16_Units	300	1	16	5	0	329.543164	0.858850	0.840960	0.884495	0.862178	RNN
20	RNN_500_Dims_1_Layers_16_Units	500	1	16	5	0	358.671691	0.800416	0.893283	0.681582	0.773203	RNN
21	RNN_100_Dims_1_Bidirectional_16_Units	100	1	16	5	1	545.693536	0.815608	0.926460	0.684964	0.787616	RNN
22	RNN_300_Dims_1_Bidirectional_16_Units	300	1	16	5	1	572.203643	0.831061	0.900472	0.743757	0.814646	RNN
23	RNN_500_Dims_1_Bidirectional_16_Units	500	1	16	5	1	602.046327	0.856123	0.869131	0.837929	0.853245	RNN
24	RNN_100_Dims_2_Layers_16_Units	100	2	16	5	0	575.141701	0.790936	0.927642	0.630333	0.750620	RNN

	Model	Embed_Dims	Layers	Units	Epochs	Bidirectional	Time	Test Accuracy	Test Precision	Test Recall	Test F1	Type
0	RNN_100_Dims_1_Layers_8_Units	100	1	8	5	0	298.059914	0.833009	0.898691	0.750000	0.817640	RNN
1	RNN_300_Dims_1_Layers_8_Units	300	1	8	5	0	327.749509	0.835865	0.893773	0.761707	0.822472	RNN
2	RNN_500_Dims_1_Layers_8_Units	500	1	8	5	0	357.598534	0.827035	0.859473	0.781217	0.818479	RNN
3	RNN_100_Dims_1_Bidirectional_8_Units	100	1	8	5	1	534.179945	0.840410	0.883994	0.783038	0.830459	RNN
4	RNN_300_Dims_1_Bidirectional_8_Units	300	1	8	5	1	556.481392	0.844436	0.867500	0.812435	0.839065	RNN
...	...	...	...	...	...	...	...	...	...	...	...	...
262	GRU_4_Dims_1_Bidirectional_8_Units	4	1	8	5	1	29.435921	0.809246	0.941943	0.658429	0.775073	GRU
263	GRU_8_Dims_1_Bidirectional_8_Units	8	1	8	5	1	29.588261	0.868329	0.902446	0.825442	0.862228	GRU
264	GRU_16_Dims_1_Bidirectional_8_Units	16	1	8	5	1	30.114233	0.845345	0.913111	0.762747	0.831184	GRU
265	GRU_32_Dims_1_Bidirectional_8_Units	32	1	8	5	1	32.265414	0.852876	0.908899	0.783819	0.841738	GRU
266	GRU_64_Dims_1_Bidirectional_8_Units	64	1	8	5	1	36.857818	0.826776	0.922275	0.713059	0.804284	GRU

	Model	Embed_Dims	Layers	Units	Epochs	Bidirectional	Time	Test Accuracy	Test Precision	Test Recall	Test F1	Type
191	GRU_500_Dims_2_Bidirectional_8_Units	500	2	8	5	1	115.990555	0.884560	0.917255	0.844953	0.879621	GRU
235	GRU_300_Dims_1_Layers_64_Units	300	1	64	5	0	52.646481	0.884431	0.906663	0.856660	0.880952	GRU
185	GRU_500_Dims_1_Bidirectional_8_Units	500	1	8	5	1	89.673430	0.884301	0.901550	0.862383	0.881532	GRU
150	LSTM_500_Dims_1_Layers_64_Units	500	1	64	5	0	83.880702	0.884301	0.900678	0.863424	0.881658	LSTM
250	GRU_300_Dims_3_Bidirectional_64_Units	300	3	64	5	1	137.686554	0.884041	0.924360	0.836108	0.878022	GRU
...	...	...	...	...	...	...	...	...	...	...	...	...
63	RNN_100_Dims_2_Bidirectional_64_Units	100	2	64	5	1	735.667118	0.729645	0.718069	0.754683	0.735921	RNN
103	LSTM_100_Dims_2_Bidirectional_8_Units	100	2	8	5	1	67.191284	0.722893	0.969265	0.459417	0.623367	LSTM
54	RNN_100_Dims_1_Layers_64_Units	100	1	64	5	0	286.290849	0.713674	0.763251	0.618106	0.683053	RNN
52	RNN_300_Dims_3_Bidirectional_32_Units	300	3	32	5	1	1489.468505	0.710557	0.796330	0.564516	0.660679	RNN
68	RNN_500_Dims_3_Layers_64_Units	500	3	64	5	0	623.889576	0.671861	0.669760	0.675858	0.672796	RNN

		Bidirectional	Time	Test Accuracy	Test Precision	Test Recall	Test F1
Type	Bidirectional
GRU	0	0	64.901178	0.854251	0.936540	0.761136	0.837226
GRU	1	1	85.024177	0.845885	0.916091	0.765716	0.831018
LSTM	0	0	65.287076	0.859977	0.916448	0.794719	0.848328
LSTM	1	1	98.802764	0.846849	0.923294	0.762639	0.828954
RNN	0	0	435.107013	0.804683	0.856024	0.740433	0.789163
RNN	1	1	990.123492	0.794821	0.847972	0.726435	0.777755

Libraries¶

EDA¶

Models¶

Setup¶

Simple RNN¶

RNN Analysis¶

Top Performer¶

Reduce RNN Units¶

Reduce Word Embedding Dimensions¶

RNN Summary¶

LSTM¶

LSTM Analysis¶

Top Performer¶

Reduce LSTM Units¶

Reduce Word Embedding Dimensions¶

LSTM Summary¶

GRU¶

GRU Analysis¶

Top Performer¶

Reduce GRU Units¶

Reduce Word Embedding Dimensions¶

GRU Summary¶

Overall Summary¶

	Model	Embed_Dims	LSTM Layers	LSTM Units	Bidirectional	Epochs	Time	Test Accuracy	Test Precision	Test Recall	Test F1
2	LSTM_500_Dims_1_Layers_8_Units	500	1	8	0	5	80.314639	0.882223	0.877409	0.888137	0.882741
56	LSTM_500_Dims_1_Layers_64_Units	500	1	64	0	5	83.880702	0.884301	0.900678	0.863424	0.881658
7	LSTM_300_Dims_2_Layers_8_Units	300	2	8	0	5	66.540332	0.876769	0.846707	0.919615	0.881656
80	LSTM_2_Dims_1_Layers_8_Units	2	1	8	0	5	20.338643	0.876899	0.852311	0.911290	0.880815
41	LSTM_500_Dims_1_Bidirectional_32_Units	500	1	32	1	5	98.511660	0.883781	0.909015	0.852497	0.879850